    


import numpy as np

arr = np.random.randint(18, 70, size=9)  # 默认数据类型（通常为int64）
arr = arr.astype(np.int32)  # 转换为int32
print(
    arr       , "\n"
    , arr.shape  , "\n"
    , arr.ndim  , "\n"   # 数组的维度数（秩）
    , arr.size  , "\n"   # 数组中元素的总数
    , arr.dtype  , "\n"  # int32, float64, complex128, bool_, object_, string_, unicode_ 等
    , arr.itemsize  , "\n"  # 数组中每个元素的字节大小
    , arr.nbytes  , "\n"    # 整个数组数据占用的总字节数（.size * .itemsize）
    , arr.strides  , "\n"   # 遍历数组时，在每个维度上需要跨越的字节数（元组）
    , arr.flags  , "\n"   # 查看属性信息，如：C_CONTIGUOUS : True 表示行连续
      
      )


# ------------------------- 创建数组 ---------------------------
arr2 = np.array([1,2,3,4,5,6])  # 列表、元组
np.array([[1.5, 'a'], [True, 3]])         # 所有元素自动统一为字符串类型
np.asarray([])
np.zeros(shape)
np.ones(shape)
np.empty(shape)
np.eye(shape)  # 对角线为1
np.arange(范围+步长)
np.linspace(0, 1, 5, endpoint=False)  # [0., 0.2, 0.4, 0.6, 0.8]  不包括结束点
np.logspace(0, 3, 4, base=2)  # [1, 2, 4, 8] (2^0~2^3) 底数为2，默认是10
def index_func(i, j):
    return i * 10 + j
np.fromfunction(index_func, (3, 3))  # [[0,1,2], [10,11,12], [20,21,22]]
#  i 矩阵
# [[0, 0, 0],
#  [1, 1, 1],
#  [2, 2, 2]]
#  j 矩阵
# [[0, 1, 2],
#  [0, 1, 2],
#  [0, 1, 2]]
np.copy(orig)  # 修改 copy_arr 不影响 orig






# ------------------------- 数组操作与变形 ---------------------------
arr = np.array([[1, 2], [3, 4]])
arr.resize((2, 3))  # 扩大形状，缺失位置补0
print(arr)
# 输出：[[1, 2, 0],
#        [3, 4, 0]]

arr.reshape((2, 3))  # 2行3列





np.round(x)：四舍五入
np.floor(x)：向下取整
np.ceil(x)：向上取整
np.trunc(x)：截断小数

np.bincount(x)：整数数组各值出现次数


# 多项式表示
p = np.array([2, 3, 1])  # 表示 2x² + 3x + 1
print(np.polyval(p, 2))  # 计算 x=2 时的值




# 多项式: 1 + 2x + 3x² + 4x³
coeffs = np.array([1, 2, 3, 4])  # 低次项在前
# 在点 x=2 处求值
result = np.polyval(coeffs, 2)  # 输出: 1 + 2*2 + 3*4 + 4*8 = 49


sum_pq = np.polyadd(p, q)  # p(x) + q(x)
diff_pq = np.polysub(p, q)  # p(x) - q(x)
product_pq = np.polymul(p, q)  # p(x) * q(x)
quotient, remainder = np.polydiv(p, q)  # p(x) / q(x) = quotient(x) + remainder(x)/q(x)
derivative = np.polyder(p)  # p'(x)
derivative_m = np.polyder(p, m)  # m 阶导数
integral = np.polyint(p)  # ∫ p(x) dx (积分常数默认为 0)
integral_k = np.polyint(p, k=5)  # 积分常数设为 5
integral_m = np.polyint(p, m=3)  # 3 重积分






# 创建 C 连续数组 (行优先)
arr_c = np.ones((1000, 1000), order='C')
# 创建 Fortran 连续数组 (列优先)
arr_f = np.ones((1000, 1000), order='F')
# 按行操作时使用 C 连续
np.sum(arr_c, axis=1)  # 快速
# 按列操作时使用 F 连续
np.sum(arr_f, axis=0)  # 快速
# 转换内存布局  如果输入数组不是连续的，它会进行内存复制操作，这可能会导致额外的性能开销。
arr_contiguous = np.ascontiguousarray(arr)  # 转为 C 连续





# 低效：创建中间副本
a = a * 2 + 3  # 创建临时数组
# 高效：原地操作
a *= 2          # 无副本
a += 3          # 无副本
# 使用 out 参数
np.multiply(a, 2, out=a)
np.add(a, 3, out=a)






# 设置 BLAS 线程数 (需底层 BLAS 支持)
import os
os.environ["OMP_NUM_THREADS"] = "4"  # 控制矩阵运算线程
os.environ["MKL_NUM_THREADS"] = "4"